ebab7d0da53c51438720d60c6e2e467c - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>JavaScript syntax</title>

</head>

JavaScript syntax

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

The <a href="Syntax_(programming_languages)" title="Syntax (programming languages)">syntax</a> of <a href="JavaScript" title="JavaScript">JavaScript</a> is the set of rules that define a correctly structured JavaScript program.

The examples below make use of the <code>console.log()</code> function present in most browsers for <a href="Standard_streams#Standard_output_.28stdout.29" title="Standard streams">standard text output</a>.

The JavaScript <a href="Standard_library" title="Standard library">standard library</a> lacks an official standard text output function (with the exception of <code>document.write</code>). Given that JavaScript is mainly used for <a href="Client-side_scripting" class="mw-redirect" title="Client-side scripting">client-side scripting</a> within modern <a href="Web_browser" title="Web browser">web browsers</a>, and that almost all Web browsers provide the alert function, <code>alert</code> can also be used, but is not commonly used.

<div class="mw-heading mw-heading2"><h2 id="Origins">Origins</h2></div>

<a href="Brendan_Eich" title="Brendan Eich">Brendan Eich</a> summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification<a href="#cite_note-1">[1]</a><a href="#cite_note-2">[2]</a> as follows:

/* start https://en.wikipedia.org/ */

.mw-parser-output .templatequote{overflow:hidden;margin:1em 0;padding:0 32px}.mw-parser-output .templatequotecite{line-height:1.5em;text-align:left;margin-top:0}@media(min-width:500px){.mw-parser-output .templatequotecite{padding-left:1.6em}}

/* end https://en.wikipedia.org/ */

</style><blockquote class="templatequote">JavaScript borrows most of its syntax from <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, but also inherits from <a href="Awk" class="mw-redirect" title="Awk">Awk</a> and <a href="Perl" title="Perl">Perl</a>, with some indirect influence from <a href="Self_(programming_language)" title="Self (programming language)">Self</a> in its object prototype system.</blockquote>

<div class="mw-heading mw-heading2"><h2 id="Basics">Basics</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Case_sensitivity">Case sensitivity</h3></div>

JavaScript is <a href="Case_sensitivity" title="Case sensitivity">case sensitive</a>. It is common to start the name of a <a href="#Constructors">constructor</a> with a <a href="CamelCase" class="mw-redirect" title="CamelCase">capitalized</a> letter, and the name of a function or variable with a lower-case letter.

Example:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>var a = 5;

console.log(a); // 5

console.log(A); // throws a ReferenceError: A is not defined

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Whitespace_and_semicolons">Whitespace and semicolons</h3></div>

Unlike in <a href="C_(programming_language)" title="C (programming language)">C</a>, whitespace in JavaScript source can directly impact <a href="Semantics_(computer_science)" title="Semantics (computer science)">semantics</a>. <a href="Semicolon" title="Semicolon">Semicolons</a> end statements in JavaScript. Because of <a href="Lexical_analysis#Semicolon_insertion" title="Lexical analysis">automatic semicolon insertion</a> (ASI), some statements that are well formed when a newline is <a href="Parsing" title="Parsing">parsed</a> will be considered complete, as if a semicolon were inserted just prior to the newline. Some authorities advise supplying statement-terminating semicolons explicitly, because it may lessen unintended effects of the automatic semicolon insertion.<a href="#cite_note-3">[3]</a>

There are two issues: five tokens can either begin a statement or be the extension of a complete statement; and five restricted productions, where line breaks are not allowed in certain positions, potentially yielding incorrect parsing.

The five problematic tokens are the open parenthesis "<code>(</code>", open bracket "<code>[</code>", slash "<code>/</code>", plus "<code>+</code>", and minus "<code>-</code>". Of these, the open parenthesis is common in the <a href="Immediately_invoked_function_expression" title="Immediately invoked function expression">immediately invoked function expression</a> pattern, and open bracket occurs sometimes, while others are quite rare. An example:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>a = b + c

(d + e).foo()

// Treated as:

// a = b + c(d + e).foo();

</pre></div>

with the suggestion that the preceding statement be terminated with a semicolon.

Some suggest instead the use of leading semicolons on lines starting with '<code>(</code>' or '<code>[</code>', so the line is not accidentally joined with the previous one. This is known as a defensive semicolon, and is particularly recommended, because code may otherwise become ambiguous when it is rearranged. For example:

;(d + e).foo()

// Treated as:

// a = b + c;

// (d + e).foo();

</pre></div>

Initial semicolons are also sometimes used at the start of JavaScript libraries, in case they are appended to another library that omits a trailing semicolon, as this can result in ambiguity of the initial statement.

The five restricted productions are <code>return</code>, <code>throw</code>, <code>break</code>, <code>continue</code>, and post-increment/decrement. In all cases, inserting semicolons does not fix the problem, but makes the parsed syntax clear, making the error easier to detect. <code>return</code> and <code>throw</code> take an optional value, while <code>break</code> and <code>continue</code> take an optional label. In all cases, the advice is to keep the value or label on the same line as the statement. This most often shows up in the return statement, where one might return a large object literal, which might be accidentally placed starting on a new line. For post-increment/decrement, there is potential ambiguity with pre-increment/decrement, and again it is recommended to simply keep these on the same line.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>return

a + b;

// Returns undefined. Treated as:

// return;

// a + b;

// Should be written as:

// return a + b;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Comments">Comments</h3></div>

<a href="Comment_(computer_programming)" title="Comment (computer programming)">Comment</a> syntax is the same as in <a href="C%2B%2B" title="C++">C++</a>, <a href="Swift_(programming_language)" title="Swift (programming language)">Swift</a> and other programming languages.

Single-line comments begin with <code>//</code> and continue until the end of the line. A second type of comments can also be made; these start with <code>/*</code> and end with <code>*/</code> and can be used for multi-line comments.

A third type of comment, the hashbang comment, starts with <code>#!</code> and continues until the end of the line. They are only valid at the start of files and are intended for use in <a href="Command-line_interface" title="Command-line interface">CLI</a> environments.<a href="#cite_note-4">[4]</a>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>#! Hashbang comment

// One-line comment

/* Multi-line

comment */

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Variables">Variables</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">Variable (programming)</a></div>

<a href="Variable_(programming)" class="mw-redirect" title="Variable (programming)">Variables</a> in standard JavaScript have no <a href="Type_system" title="Type system">type</a> attached, so any value (each value has a type) can be stored in any variable. Starting with <a href="ECMAScript#6th_Edition_–_ECMAScript_2015" title="ECMAScript">ES6</a>, the 6th version of the language, variables could be declared with <code>var</code> for function scoped variables, and <code>let</code> or <code>const</code> which are for <a href="Block_scope" class="mw-redirect" title="Block scope">block level</a> variables. Before ES6, variables could only be declared with a <code>var</code> statement. Values assigned to variables declared with <code>const</code> cannot be changed, but their properties can. <code>var</code> should no longer be used since <code>let</code> and <code>const</code> are supported by modern browsers.<a href="#cite_note-5">[5]</a> A variable's <a href="Identifier_(computer_languages)" title="Identifier (computer languages)">identifier</a> must start with a letter, underscore (<code>_</code>), or dollar sign (<code>$</code>), while subsequent characters can also be digits (<code>0-9</code>). JavaScript is case sensitive, so the uppercase characters "A" through "Z" are different from the lowercase characters "a" through "z".

Starting with JavaScript 1.5, <a href="ISO_8859-1" class="mw-redirect" title="ISO 8859-1">ISO 8859-1</a> or <a href="Unicode" title="Unicode">Unicode</a> letters (or <code>\uXXXX</code> Unicode escape sequences) can be used in identifiers.<a href="#cite_note-6">[6]</a> In certain JavaScript implementations, the at sign (@) can be used in an identifier, but this is contrary to the specifications and not supported in newer implementations.

<div class="mw-heading mw-heading3"><h3 id="Scoping_and_hoisting">Scoping and hoisting</h3></div>

Variables declared with <code>var</code> are <a href="Lexical_scoping" class="mw-redirect" title="Lexical scoping">lexically scoped</a> at a <a href="Function_scope" class="mw-redirect" title="Function scope">function level</a>, while ones with <code>let</code> or <code>const</code> have a <a href="Block_scope" class="mw-redirect" title="Block scope">block level</a> scope. Since declarations are processed before any code is executed, a variable can be assigned to and used prior to being declared in the code.<a href="#cite_note-7">[7]</a> This is referred to as <style data-mw-deduplicate="TemplateStyles:r1238216509">

/* start https://en.wikipedia.org/ */

.mw-parser-output .vanchor>:target~.vanchor-text{background-color:#b1d2ff}@media screen{html.skin-theme-clientpref-night .mw-parser-output .vanchor>:target~.vanchor-text{background-color:#0f4dc9}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .vanchor>:target~.vanchor-text{background-color:#0f4dc9}}

/* end https://en.wikipedia.org/ */

</style>hoisting, and it is equivalent to variables being <a href="Forward_declaration" title="Forward declaration">forward declared</a> at the top of the function or block.<a href="#cite_note-8">[8]</a>

With <code>var</code>, <code>let</code>, and <code>const</code> statements, only the declaration is hoisted; assignments are not hoisted. Thus a <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">var x = 1</code> statement in the middle of the function is equivalent to a <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">var x</code> declaration statement at the top of the function, and an <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">x = 1</code> assignment statement at that point in the middle of the function. This means that values cannot be accessed before they are declared; <a href="Forward_reference" class="mw-redirect" title="Forward reference">forward reference</a> is not possible. With <code>var</code> a variable's value is <code>undefined</code> until it is initialized. Variables declared with <code>let</code> or <code>const</code> cannot be accessed until they have been initialized, so referencing such variables before will cause an error.

Function declarations, which declare a variable and assign a function to it, are similar to variable statements, but in addition to hoisting the declaration, they also hoist the assignment – as if the entire statement appeared at the top of the containing function – and thus forward reference is also possible: the location of a function statement within an enclosing function is irrelevant. This is different from a function expression being assigned to a variable in a <code>var</code>, <code>let</code>, or <code>const</code> statement.

So, for example,

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>var func = function() { .. } // declaration is hoisted only

function func() { .. } // declaration and assignment are hoisted

</pre></div>

Block scoping can be produced by wrapping the entire block in a function and then executing it – this is known as the <a href="Immediately-invoked_function_expression" class="mw-redirect" title="Immediately-invoked function expression">immediately-invoked function expression</a> pattern – or by declaring the variable using the <code>let</code> keyword.

<div class="mw-heading mw-heading3"><h3 id="Declaration_and_assignment">Declaration and assignment</h3></div>

Variables declared outside a scope are <a href="Global_variable" title="Global variable">global</a>. If a variable is declared in a higher scope, it can be accessed by child scopes.

When JavaScript tries to resolve an identifier, it looks in the local scope. If this identifier is not found, it looks in the next outer scope, and so on along the scope chain until it reaches the global scope where global variables reside. If it is still not found, JavaScript will raise a <code>ReferenceError</code> exception.

When assigning an identifier, JavaScript goes through exactly the same process to retrieve this identifier, except that if it is not found in the global scope, it will create the "variable" in the scope where it was created.<a href="#cite_note-9">[9]</a> As a consequence, a variable never declared will be global, if assigned. Declaring a variable (with the keyword <code>var</code>) in the global scope (i.e. outside of any function body (or block in the case of let/const)), assigning a never declared identifier or adding a property to the global object (usually window) will also create a new global variable.

Note that JavaScript's strict mode forbids the assignment of an undeclared variable, which avoids global namespace pollution.

<div class="mw-heading mw-heading3"><h3 id="Examples">Examples</h3></div>

Here are some examples of variable declarations and scope:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>var x1 = 0; // A global variable, because it is not in any function

let x2 = 0; // Also global, this time because it is not in any block

function f() {

var z = 'foxes', r = 'birds'; // 2 local variables

m = 'fish'; // global, because it was not declared anywhere before

function child() {

var r = 'monkeys'; // This variable is local and does not affect the "birds" r of the parent function.

z = 'penguins'; // Closure: Child function is able to access the variables of the parent function.

}

twenty = 20; // This variable is declared on the next line, but usable anywhere in the function, even before, as here

var twenty;

child();

return x1 + x2; // We can use x1 and x2 here, because they are global

}

f();

console.log(z); // This line will raise a ReferenceError exception, because the value of z is no longer available

</pre></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>for (let i = 0; i < 10; i++) console.log(i);

console.log(i); // throws a ReferenceError: i is not defined

</pre></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>for (const i = 0; i < 10; i++) console.log(i); // throws a TypeError: Assignment to constant variable

for (const i of [1,2,3]) console.log(i); //will not raise an exception. i is not reassigned but recreated in every iteration

const pi; // throws a SyntaxError: Missing initializer in const declaration

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Primitive_data_types">Primitive data types</h2></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Primitive_data_type" title="Primitive data type">Primitive data type</a></div>

The JavaScript language provides six <a href="Primitive_data_type" title="Primitive data type">primitive data types</a>:

<ul><li>Undefined</li>

<li>Number</li>

<li>BigInt</li>

<li>String</li>

<li>Boolean</li>

<li>Symbol</li></ul>

Some of the primitive data types also provide a set of named values that represent the extents of the type boundaries. These named values are described within the appropriate sections below.

<div class="mw-heading mw-heading3"><h3 id="Undefined">Undefined</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Undefined_value" title="Undefined value">Undefined value</a></div>

The <a href="Undefined_value" title="Undefined value">value of "undefined"</a> is assigned to all <a href="Uninitialized_variable" title="Uninitialized variable">uninitialized variables</a>, and is also returned when checking for object properties that do not exist. In a Boolean context, the undefined value is considered a false value.

Note: undefined is considered a genuine primitive type. Unless explicitly converted, the undefined value may behave unexpectedly in comparison to other types that evaluate to false in a logical context.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let test; // variable declared, but not defined, ...

// ... set to value of undefined

const testObj = {};

console.log(test); // test variable exists, but value not ...

// ... defined, displays undefined

console.log(testObj.myProp); // testObj exists, property does not, ...

// ... displays undefined

console.log(undefined == null); // unenforced type during check, displays true

console.log(undefined === null); // enforce type during check, displays false

</pre></div>

Note: There is no built-in language literal for undefined. Thus <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">(x === undefined)</code> is not a foolproof way to check whether a variable is undefined, because in versions before ECMAScript 5, it is legal for someone to write <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">var undefined = "I'm defined now";</code>. A more robust approach is to compare using <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">(typeof x === 'undefined')</code>.

Functions like this will not work as expected:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function isUndefined(x) { let u; return x === u; } // like this...

function isUndefined(x) { return x === void 0; } // ... or that second one

function isUndefined(x) { return (typeof x) === "undefined"; } // ... or that third one

</pre></div>

Here, calling <code>isUndefined(my_var)</code> raises a <style data-mw-deduplicate="TemplateStyles:r886049734">

/* start https://en.wikipedia.org/ */

.mw-parser-output .monospaced{font-family:monospace,monospace}

/* end https://en.wikipedia.org/ */

</style>ReferenceError if my_var is an unknown identifier, whereas <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">typeof my_var === 'undefined'</code> does not.

<div class="mw-heading mw-heading3"><h3 id="Number">Number</h3></div>

Numbers are represented in binary as <a href="IEEE_754" title="IEEE 754">IEEE 754</a> <a href="Floating_point" class="mw-redirect" title="Floating point">floating point</a> doubles. Although this format provides an accuracy of nearly 16 <a href="Significant_digits" class="mw-redirect" title="Significant digits">significant digits</a>, it cannot always exactly represent real numbers, including fractions.

This becomes an issue when comparing or formatting numbers. For example:

console.log(0.94 - 0.01); // displays 0.9299999999999999

</pre></div>

As a result, a routine such as the toFixed() method should be used to round numbers whenever they are <a rel="nofollow" class="external text" href="http://www.jibbering.com/faq/#formatNumber">formatted for output</a>.

Numbers may be specified in any of these notations:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>345; // an "integer", although there is only one numeric type in JavaScript

34.5; // a floating-point number

3.45e2; // another floating-point, equivalent to 345

0b1011; // a binary integer equal to 11

0o377; // an octal integer equal to 255

0xFF; // a hexadecimal integer equal to 255, digits represented by the ...

// ... letters A-F may be upper or lowercase

</pre></div>

There is also a numeric separator, _ (the underscore), introduced in ES2021:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Note: Wikipedia syntax does not support numeric separators yet

1_000_000_000; // Used with big numbers

1_000_000.5; // Support with decimals

1_000e1_000; // Support with exponents

// Support with binary, octals and hex

0b0000_0000_0101_1011;

0o0001_3520_0237_1327;

0xFFFF_FFFF_FFFF_FFFE;

// But users cannot use them next to a non-digit number part, or at the start or end

_12; // Variable is not defined (the underscore makes it a variable identifier)

12_; // Syntax error (cannot be at the end of numbers)

12_.0; // Syntax error (does not make sense to put a separator next to the decimal point)

12._0; // Syntax error

12e_6; // Syntax error (next to "e", a non-digit. Does not make sense to put a separator at the start)

1000____0000; // Syntax error (next to "_", a non-digit. Only 1 separator at a time is allowed

</pre></div>

The extents <a href="Extended_real_number_line" title="Extended real number line">+∞, −∞</a> and <a href="NaN" title="NaN">NaN</a> (Not a Number) of the number type may be obtained by two program expressions:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>Infinity; // positive infinity (negative obtained with -Infinity for instance)

NaN; // The Not-A-Number value, also returned as a failure in ...

// ... string-to-number conversions

</pre></div>

Infinity and NaN are numbers:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>typeof Infinity; // returns "number"

typeof NaN; // returns "number"

</pre></div>

These three special values correspond and behave as the <a href="IEEE-754" class="mw-redirect" title="IEEE-754">IEEE-754</a> describes them.

The Number constructor (used as a function), or a unary + or -, may be used to perform explicit numeric conversion:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const myString = "123.456";

const myNumber1 = Number(myString);

const myNumber2 = +myString;

</pre></div>

When used as a constructor, a numeric wrapper object is created (though it is of little use):

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const myNumericWrapper = new Number(123.456);

</pre></div>

However, NaN is not equal to itself:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const nan = NaN;

console.log(NaN == NaN); // false

console.log(NaN === NaN); // false

console.log(NaN !== NaN); // true

console.log(nan !== nan); // true

// Users can use the isNaN methods to check for NaN

console.log(isNaN("converted to NaN")); // true

console.log(isNaN(NaN)); // true

console.log(Number.isNaN("not converted")); // false

console.log(Number.isNaN(NaN)); // true

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="BigInt">BigInt</h3></div>

In JavaScript, regular numbers are represented with the IEEE 754 floating point type, meaning integers can only safely be stored if the value falls between <code>Number.MIN_SAFE_INTEGER</code> and <code>Number.MAX_SAFE_INTEGER</code>. <a href="#cite_note-10">[10]</a> BigInts instead represent <a href="Integers" class="mw-redirect" title="Integers">integers</a> of any size, allowing programmers to store integers too high or low to be represented with the IEEE 754 format.<a href="#cite_note-bigint-mdn-11">[11]</a>

There are two ways to declare a BigInt value. An <code>n</code> can be appended to an integer, or the <code>BigInt</code> function can be used:<a href="#cite_note-bigint-mdn-11">[11]</a>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const a = 12345n; // Creates a variable and stores a BigInt value of 12345

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="String">String</h3></div>

A <a href="String_(computer_science)" title="String (computer science)">string</a> in JavaScript is a sequence of characters. In JavaScript, strings can be created directly (as literals) by placing the series of characters between double (<code>"</code>) or single (<code>'</code>) quotes. Such strings must be written on a single line, but may include escaped newline characters (such as <code>\n</code>). The JavaScript standard allows the <a href="Grave_accent#Use_in_programming" title="Grave accent">backquote</a> character (<code>`</code>, a.k.a. grave accent or backtick) to quote multiline literal strings, as well as embedded expressions using the syntax <code>${expression}</code>.<a href="#cite_note-12">[12]</a>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const greeting = "Hello, World!";

const anotherGreeting = 'Greetings, people of Earth.';

const aMultilineGreeting = `Warm regards,

John Doe.`

// Template literals type-coerce evaluated expressions and interpolate them into the string.

const templateLiteral = `This is what is stored in anotherGreeting: ${anotherGreeting}.`;

console.log(templateLiteral); // 'This is what is stored in anotherGreeting: 'Greetings, people of Earth.''

console.log(`You are ${Math.floor(age)=>18 ? "allowed" : "not allowed"} to view this web page`);

</pre></div>

Individual characters within a string can be accessed using the charAt method (provided by String.prototype). This is the preferred way when accessing individual characters within a string, because it also works in non-modern browsers:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const h = greeting.charAt(0);

</pre></div>

In modern browsers, individual characters within a string can be accessed (as strings with only a single character) through the same notation as arrays:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const h = greeting[0];

</pre></div>

However, JavaScript strings are <a href="Immutable_object" title="Immutable object">immutable</a>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>greeting[0] = "H"; // Fails.

</pre></div>

Applying the equality operator ("==") to two strings returns true, if the strings have the same contents, which means: of the same length and containing the same sequence of characters (case is significant for alphabets). Thus:

const compare1 = ("Hello, " + x == "Hello, World"); // Here compare1 contains true.

const compare2 = ("Hello, " + x == "hello, World"); // Here compare2 contains ...

// ... false since the ...

// ... first characters ...

// ... of both operands ...

// ... are not of the same case.

</pre></div>

Quotes of the same type cannot be nested unless they are <a href="String_literal#Escape_character" title="String literal">escaped</a>.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let x = '"Hello, World!" he said.'; // Just fine.

x = ""Hello, World!" he said."; // Not good.

x = "\"Hello, World!\" he said."; // Works by escaping " with \"

</pre></div>

The String constructor creates a string object (an object wrapping a string):

</pre></div>

These objects have a valueOf method returning the primitive string wrapped within them:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const s = new String("Hello !");

typeof s; // Is 'object'.

typeof s.valueOf(); // Is 'string'.

</pre></div>

Equality between two String objects does not behave as with string primitives:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const s1 = new String("Hello !");

const s2 = new String("Hello !");

s1 == s2; // Is false, because they are two distinct objects.

s1.valueOf() == s2.valueOf(); // Is true.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Boolean">Boolean</h3></div>

<a href="JavaScript" title="JavaScript">JavaScript</a> provides a <a href="Boolean_data_type" title="Boolean data type">Boolean data type</a> with true and false literals. The <a href="Typeof" title="Typeof">typeof</a> operator returns the string "boolean" for these <a href="Primitive_types" class="mw-redirect" title="Primitive types">primitive types</a>. When used in a logical context, 0, -0, null, NaN, undefined, and the empty string ("") evaluate as false due to automatic <a href="Type_conversion" title="Type conversion">type conversion</a>. All other values (the <a href="Complement_(set_theory)" title="Complement (set theory)">complement</a> of the previous list) evaluate as true, including the strings "0", "false" and any object.

<div class="mw-heading mw-heading3"><h3 id="Type_conversion">Type conversion</h3></div>

Automatic type coercion by the equality comparison operators (<code>==</code> and <code>!=</code>) can be avoided by using the type checked comparison operators (<code>===</code> and <code>!==</code>).

When type conversion is required, JavaScript converts Boolean, Number, String, or Object operands as follows:<a href="#cite_note-13">[13]</a>

<dl><dt>Number and String</dt>

<dd>The string is converted to a number value. JavaScript attempts to convert the string numeric literal to a Number type value. First, a mathematical value is derived from the string numeric literal. Next, this value is rounded to nearest Number type value.</dd>

<dt>Boolean</dt>

<dd>If one of the operands is a Boolean, the Boolean operand is converted to 1 if it is true, or to 0 if it is false.</dd>

<dt>Object</dt>

<dd>If an object is compared with a number or string, JavaScript attempts to return the default value for the object. An object is converted to a primitive String or Number value, using the .valueOf() or .toString() methods of the object. If this fails, a runtime error is generated.</dd></dl>

<div class="mw-heading mw-heading4"><h4 id="Boolean_type_conversion">Boolean type conversion</h4></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Truthy_(computing)" class="mw-redirect" title="Truthy (computing)">Truthy (computing)</a></div>

<a href="Douglas_Crockford" title="Douglas Crockford">Douglas Crockford</a> advocates the terms "truthy" and "falsy" to describe how values of various types behave when evaluated in a logical context, especially in regard to edge cases.<a href="#cite_note-14">[14]</a>

The binary logical operators returned a Boolean value in early versions of JavaScript, but now they return one of the operands instead. The left–operand is returned, if it can be evaluated as : false, in the case of <a href="Logical_conjunction" title="Logical conjunction">conjunction</a>: (<code>a && b</code>), or true, in the case of <a href="Logical_disjunction" title="Logical disjunction">disjunction</a>: (<code>a || b</code>); otherwise the right–operand is returned. Automatic type coercion by the comparison operators may differ for cases of mixed Boolean and number-compatible operands (including strings that can be evaluated as a number, or objects that can be evaluated as such a string), because the Boolean operand will be compared as a numeric value. This may be unexpected. An expression can be explicitly cast to a Boolean primitive by doubling the logical <a href="Negation" title="Negation">negation operator</a>: (!!), using the Boolean() function, or using the <a href="Conditional_(programming)" class="mw-redirect" title="Conditional (programming)">conditional operator</a>: (<code>c ? t : f</code>).

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Automatic type coercion

console.log(true == 2 ); // false... true → 1 !== 2 ← 2

console.log(false == 2 ); // false... false → 0 !== 2 ← 2

console.log(true == 1 ); // true.... true → 1 === 1 ← 1

console.log(false == 0 ); // true.... false → 0 === 0 ← 0

console.log(true == "2"); // false... true → 1 !== 2 ← "2"

console.log(false == "2"); // false... false → 0 !== 2 ← "2"

console.log(true == "1"); // true.... true → 1 === 1 ← "1"

console.log(false == "0"); // true.... false → 0 === 0 ← "0"

console.log(false == "" ); // true.... false → 0 === 0 ← ""

console.log(false == NaN); // false... false → 0 !== NaN

// Type checked comparison (no conversion of types and values)

console.log(true === 1); // false...... data types do not match

// Explicit type coercion

console.log(true === !!2); // true.... data types and values match

console.log(true === !!0); // false... data types match, but values differ

console.log( 1 ? true : false); // true.... only ±0 and NaN are "falsy" numbers

console.log(Boolean({})); // true.... all objects are "truthy"

</pre></div>

The new operator can be used to create an object wrapper for a Boolean primitive. However, the typeof operator does not return boolean for the object wrapper, it returns object. Because all objects evaluate as true, a method such as .valueOf(), or .toString(), must be used to retrieve the wrapped value. For explicit coercion to the Boolean type, Mozilla recommends that the Boolean() function (without new) be used in preference to the Boolean object.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const b = new Boolean(false); // Object false {}

const t = Boolean(b); // Boolean true

const f = Boolean(b.valueOf()); // Boolean false

let n = new Boolean(b); // Not recommended

n = new Boolean(b.valueOf()); // Preferred

if (0 || -0 || "" || null || undefined || b.valueOf() || !new Boolean() || !t) {

console.log("Never this");

} else if ([] && {} && b && typeof b === "object" && b.toString() === "false") {

console.log("Always this");

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Symbol">Symbol</h3></div>

Symbols are a feature introduced in <a href="ES6" class="mw-redirect" title="ES6">ES6</a>. Each symbol is guaranteed to be a unique value, and they can be used for <a href="Encapsulation_(computer_programming)" title="Encapsulation (computer programming)">encapsulation</a>.<a href="#cite_note-15">[15]</a>

Example:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let x = Symbol(1);

const y = Symbol(1);

x === y; // => false

const symbolObject = {};

const normalObject = {};

// since x and y are unique,

// they can be used as unique keys in an object

symbolObject[x] = 1;

symbolObject[y] = 2;

symbolObject[x]; // => 1

symbolObject[y]; // => 2

// as compared to normal numeric keys

normalObject[1] = 1;

normalObject[1]; // => 2

// changing the value of x does not change the key stored in the object

x = Symbol(3);

symbolObject[x]; // => undefined

// changing x back just creates another unique Symbol

symbolObject[x]; // => undefined

</pre></div>

There are also well known symbols.

One of which is <code>Symbol.iterator</code>; if something implements <code>Symbol.iterator</code>, it is iterable:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const x = [1, 2, 3, 4]; // x is an Array

x[Symbol.iterator] === Array.prototype[Symbol.iterator]; // and Arrays are iterable

const xIterator = x[Symbol.iterator](); // The [Symbol.iterator] function should provide an iterator for x

xIterator.next(); // { value: 1, done: false }

xIterator.next(); // { value: 2, done: false }

xIterator.next(); // { value: 3, done: false }

xIterator.next(); // { value: 4, done: false }

xIterator.next(); // { value: undefined, done: true }

// for..of loops automatically iterate values

console.log(value); // 1 2 3 4

}

// Sets are also iterable:

[Symbol.iterator] in Set.prototype; // true

for (const value of new Set(['apple', 'orange'])) {

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Native_objects">Native objects</h2></div>

The JavaScript language provides a handful of native <a href="Object_(computer_science)" title="Object (computer science)">objects</a>. JavaScript native objects are considered part of the JavaScript specification. JavaScript environment notwithstanding, this set of objects should always be available.

<div class="mw-heading mw-heading3"><h3 id="Array">Array</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Array_data_type" class="mw-redirect" title="Array data type">Array data type</a></div>

An <a href="Array_data_type" class="mw-redirect" title="Array data type">Array</a> is a JavaScript object prototyped from the <code>Array</code> constructor specifically designed to store data values indexed by integer keys. Arrays, unlike the basic Object type, are prototyped with methods and properties to aid the programmer in routine tasks (for example, <code>join</code>, <code>slice</code>, and <code>push</code>).

As in the C family, arrays use a zero-based indexing scheme: A value that is inserted into an empty array by means of the <code>push</code> method occupies the 0th index of the array.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const myArray = []; // Point the variable myArray to a newly ...

// ... created, empty Array

myArray.push("hello World"); // Fill the next empty index, in this case 0

console.log(myArray[0]); // Equivalent to console.log("hello World");

</pre></div>

Arrays have a <code>length</code> property that is guaranteed to always be larger than the largest integer index used in the array. It is automatically updated, if one creates a property with an even larger index. Writing a smaller number to the <code>length</code> property will remove larger indices.

Elements of <code>Array</code>s may be accessed using normal object property access notation:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>myArray[1]; // the 2nd item in myArray

myArray["1"];

</pre></div>

The above two are equivalent. It is not possible to use the "dot"-notation or strings with alternative representations of the number:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>myArray.1; // syntax error

myArray["01"]; // not the same as myArray[1]

</pre></div>

Declaration of an array can use either an <code>Array</code> literal or the <code>Array</code> constructor:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let myArray;

// Array literals

myArray = [1, 2]; // length of 2

myArray = [1, 2,]; // same array - Users can also have an extra comma at the end

// It is also possible to not fill in parts of the array

myArray = [0, 1, /* hole */, /* hole */, 4, 5]; // length of 6

myArray = [0, 1, /* hole */, /* hole */, 4, 5,]; // same array

myArray = [0, 1, /* hole */, /* hole */, 4, 5, /* hole */,]; // length of 7

// With the constructor

myArray = new Array(0, 1, 2, 3, 4, 5); // length of 6

</pre></div>

<a href="Array_data_structure" class="mw-redirect" title="Array data structure">Arrays</a> are implemented so that only the defined elements use memory; they are "<a href="Sparse_array" class="mw-redirect" title="Sparse array">sparse arrays</a>". Setting <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">myArray[10] = 'someThing'</code> and <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">myArray[57] = 'somethingOther'</code> only uses space for these two elements, just like any other object. The <code>length</code> of the array will still be reported as 58. The maximum length of an array is 4,294,967,295 which corresponds to 32-bit binary number (11111111111111111111111111111111)2.

One can use the object declaration literal to create objects that behave much like associative arrays in other languages:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const dog = {color: "brown", size: "large"};

dog["color"]; // results in "brown"

dog.color; // also results in "brown"

</pre></div>

One can use the object and array declaration literals to quickly create arrays that are associative, multidimensional, or both. (Technically, JavaScript does not support multidimensional arrays, but one can mimic them with arrays-of-arrays.)

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const cats = [{color: "brown", size: "large"},

{color: "black", size: "small"}];

cats[0]["size"]; // results in "large"

const dogs = {rover: {color: "brown", size: "large"},

spot: {color: "black", size: "small"}};

dogs["spot"]["size"]; // results in "small"

dogs.rover.color; // results in "brown"

</pre></div>

A <code>Date</code> object stores a signed millisecond count with zero representing 1970-01-01 00:00:00 UT and a range of ±108 days. There are several ways of providing arguments to the <code>Date</code> constructor. Note that months are zero-based.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>new Date(); // create a new Date instance representing the current time/date.

new Date(2010, 2, 1, 14, 25, 30); // create a new Date instance representing 2010-Mar-01 14:25:30

new Date("2010-3-1 14:25:30"); // create a new Date instance from a String.

</pre></div>

Methods to extract fields are provided, as well as a useful <code>toString</code>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const d = new Date(2010, 2, 1, 14, 25, 30); // 2010-Mar-01 14:25:30;

// Displays '2010-3-1 14:25:30':

console.log(d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate() + ' '

+ d.getHours() + ':' + d.getMinutes() + ':' + d.getSeconds());

// Built-in toString returns something like 'Mon 1 March, 2010 14:25:30 GMT-0500 (EST)':

console.log(d);

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Error">Error</h3></div>

Custom error messages can be created using the <code>Error</code> class:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>throw new Error("Something went wrong.");

</pre></div>

These can be caught by try...catch...finally blocks as described in the section on <a href="#Exception_handling">exception handling</a>.

The Math object contains various math-related constants (for example, π) and functions (for example, cosine). (Note that the Math object has no constructor, unlike Array or Date. All its methods are "static", that is "class" methods.) All the trigonometric functions use angles expressed in <a href="Radian" title="Radian">radians</a>, not <a href="Degree_(angle)" title="Degree (angle)">degrees</a> or <a href="Grad_(angle)" class="mw-redirect" title="Grad (angle)">grads</a>.

<caption>Some of the constants contained in the Math object

</caption>

<th>Property</th>

<th>Returned value rounded to 5 digits</th>

<th>Description

</th></tr>

<tr>

<td><a href="E_(mathematical_constant)" title="E (mathematical constant)">e</a>: Natural logarithm base

</td></tr>

<tr>

<td><a href="Natural_logarithm" title="Natural logarithm">Natural logarithm</a> of 2

</td></tr>

<tr>

<td>Natural logarithm of 10

</td></tr>

<tr>

<td><a href="Logarithm" title="Logarithm">Logarithm</a> to the base 2 of e

</td></tr>

<tr>

<td>Logarithm to the base 10 of e

</td></tr>

<tr>

<td><a href="Pi" title="Pi">π</a>: circumference/diameter of a circle

</td></tr>

<tr>

<td><a href="Square_root" title="Square root">Square root</a> of ½

</td></tr>

<tr>

<td><a href="Square_root_of_2" title="Square root of 2">Square root of 2</a>

</td></tr></tbody></table>

<caption>Methods of the Math object

</caption>

<th>Example</th>

<th>Returned value rounded to 5 digits</th>

<th>Description

</th></tr>

<tr>

<td><a href="Absolute_value" title="Absolute value">Absolute value</a>

</td></tr>

<tr>

<td><a href="Arccosine" class="mw-redirect" title="Arccosine">Arccosine</a>

</td></tr>

<tr>

<td><a href="Arcsine" class="mw-redirect" title="Arcsine">Arcsine</a>

</td></tr>

<tr>

<td>Half circle <a href="Arctangent" class="mw-redirect" title="Arctangent">arctangent</a> (⁠<math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle -\pi /2}">

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle -\pi /2}</annotation>

</semantics>

</math><img src="./4644f935f59f6d1bac8c2ef618246eee6c1f07b3.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:5.465ex; height:2.843ex;" alt="{\displaystyle -\pi /2}" loading="lazy">⁠ to ⁠<math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle +\pi /2}">

</mrow>

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle +\pi /2}</annotation>

</semantics>

</math><img src="./b7fac17a374c4e9eae65df5546ec64b79b0e16ca.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.838ex; width:5.465ex; height:2.843ex;" alt="{\displaystyle +\pi /2}" loading="lazy">⁠)

</td></tr>

<tr>

<td>Whole circle arctangent (⁠<math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle -\pi }">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle -\pi }</annotation>

</semantics>

</math><img src="./f2359073fe90a84a705e02f0c1e63b32df850a60.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.505ex; width:3.14ex; height:2.176ex;" alt="{\displaystyle -\pi }" loading="lazy">⁠ to ⁠<math xmlns="http://www.w3.org/1998/Math/MathML" alttext="{\displaystyle +\pi }">

</mstyle>

</mrow>

<annotation encoding="application/x-tex">{\displaystyle +\pi }</annotation>

</semantics>

</math><img src="./cbae717a544919265768ad63c73919176113fb12.svg" class="mwe-math-fallback-image-inline mw-invert skin-invert" aria-hidden="true" style="vertical-align: -0.505ex; width:3.14ex; height:2.176ex;" alt="{\displaystyle +\pi }" loading="lazy">⁠)

</td></tr>

<tr>

<td>Ceiling: <a href="Rounding" title="Rounding">round</a> up to smallest integer ≥ argument

</td></tr>

<tr>

<td><a href="Trigonometric_functions" title="Trigonometric functions">Cosine</a>

</td></tr>

<tr>

<td><a href="Exponential_function" title="Exponential function">Exponential function</a>: e raised to this power

</td></tr>

<tr>

<td>Math.floor(1.9)</td>

<td>Floor: round down to largest integer ≤ argument

</td></tr>

<tr>

<td>Natural logarithm, base e

</td></tr>

<tr>

<td>Maximum: (x > y) ? x : y

</td></tr>

<tr>

<td>Minimum: (x < y) ? x : y

</td></tr>

<tr>

<td><a href="Exponentiation" title="Exponentiation">Exponentiation</a> (raised to the power of): Math.pow(x, y) gives xy

</td></tr>

<tr>

<td>Math.random()</td>

<td><a href="Pseudorandom" class="mw-redirect" title="Pseudorandom">Pseudorandom</a> number between 0 (inclusive) and 1 (exclusive)

</td></tr>

<tr>

<td>Math.round(1.5)</td>

<td>Round to the nearest integer; half fractions are rounded up (e.g. 1.5 rounds to 2)

</td></tr>

<tr>

</td></tr>

<tr>

<td>Square root

</td></tr>

<tr>

<td><a href="Trigonometric_functions" title="Trigonometric functions">Tangent</a>

</td></tr></tbody></table>

<div class="mw-heading mw-heading3"><h3 id="Regular_expression">Regular expression</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Regular_expression" title="Regular expression">Regular expression</a></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>/expression/.test(string); // returns Boolean

"string".search(/expression/); // returns position Number

"string".replace(/expression/, replacement);

// Here are some examples

if (/Tom/.test("My name is Tom")) console.log("Hello Tom!");

console.log("My name is Tom".search(/Tom/)); // == 11 (letters before Tom)

console.log("My name is Tom".replace(/Tom/, "John")); // == "My name is John"

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Character_classes">Character classes</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// \d - digit

// \D - non digit

// \s - space

// \S - non space

// \w - word char

// \W - non word

// [ ] - one of

// [^] - one not of

// - - range

if (/\d/.test('0')) console.log('Digit');

if (/[0-9]/.test('6')) console.log('Digit');

if (/[13579]/.test('1')) console.log('Odd number');

if (/\S\S\s\S\S\S\S/.test('My name')) console.log('Format OK');

if (/\w\w\w/.test('Tom')) console.log('Hello Tom');

if (/[a-zA-Z]/.test('B')) console.log('Letter');

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Character_matching">Character matching</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// A...Z a...z 0...9 - alphanumeric

// \u0000...\uFFFF - Unicode hexadecimal

// \x00...\xFF - ASCII hexadecimal

// \t - tab

// \n - new line

// \r - CR

// . - any character

// | - OR

if (/T.m/.test('Tom')) console.log ('Hi Tom, Tam or Tim');

if (/A|B/.test("A")) console.log ('A or B');

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Repeaters">Repeaters</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// ? - 0 or 1 match

// * - 0 or more

// + - 1 or more

// {n} - exactly n

// {n,} - n or more

// {0,n} - n or less

// {n,m} - range n to m

if (/ab?c/.test("ac")) console.log("OK"); // match: "ac", "abc"

if (/ab*c/.test("ac")) console.log("OK"); // match: "ac", "abc", "abbc", "abbbc" etc.

if (/ab+c/.test("abc")) console.log("OK"); // match: "abc", "abbc", "abbbc" etc.

if (/ab{3}c/.test("abbbc")) console.log("OK"); // match: "abbbc"

if (/ab{3,}c/.test("abbbc")) console.log("OK"); // match: "abbbc", "abbbbc", "abbbbbc" etc.

if (/ab{1,3}c/.test("abc")) console.log("OK"); // match: "abc", "abbc", "abbbc"

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Anchors">Anchors</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// ^ - string starts with

// $ - string ends with

if (/^My/.test("My name is Tom")) console.log ("Hi!");

if (/Tom$/.test("My name is Tom")) console.log ("Hi Tom!");

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Subexpression">Subexpression</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// ( ) - groups characters

if (/water(mark)?/.test("watermark")) console.log("Here is water!"); // match: "water", "watermark",

if (/(Tom)|(John)/.test("John")) console.log("Hi Tom or John!");

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Flags">Flags</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// /g - global

// /i - ignore upper/lower case

// /m - allow matches to span multiple lines

console.log("hi tom!".replace(/Tom/i, "John")); // == "hi John!"

console.log("ratatam".replace(/ta/, "tu")); // == "ratutam"

console.log("ratatam".replace(/ta/g, "tu")); // == "ratutum"

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Advanced_methods">Advanced methods</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>my_array = my_string.split(my_delimiter);

// example

my_array = "dog,cat,cow".split(","); // my_array==["dog","cat","cow"];

my_array = my_string.match(my_expression);

// example

my_array = "We start at 11:30, 12:15 and 16:45".match(/\d\d:\d\d/g); // my_array==["11:30","12:15","16:45"];

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Capturing_groups">Capturing groups</h4></div>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/;

const results = myRe.exec("The date and time are 2009-09-08 09:37:08.");

if (results) {

console.log("Matched: " + results[0]); // Entire match

const my_date = results[1]; // First group == "2009-09-08"

const my_time = results[2]; // Second group == "09:37:08"

console.log(`It is ${my_time} on ${my_date}`);

} else console.log("Did not find a valid date!");

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Function">Function</h3></div>

Every function in JavaScript is an instance of the <code>Function</code> constructor:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// x, y is the argument. 'return x + y' is the function body, which is the last in the argument list.

const add = new Function('x', 'y', 'return x + y');

add(1, 2); // => 3

</pre></div>

The add function above may also be defined using a function expression:

return x + y;

};

</pre></div>

In ES6, arrow function syntax was added, allowing functions that return a value to be more concise. They also retain the <code>this</code> of the global object instead of inheriting it from where it was called / what it was called on, unlike the <code>function() {}</code> expression.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const add = (x, y) => {return x + y;};

// values can also be implicitly returned (i.e. no return statement is needed)

const addImplicit = (x, y) => x + y;

addImplicit(1, 2) // => 3

</pre></div>

For functions that need to be hoisted, there is a separate expression:

}

</pre></div>

Hoisting allows users to use the function before it is "declared":

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>add(1, 2); // => 3, not a ReferenceError

function add(x, y) {

}

</pre></div>

A function instance has properties and methods.

return x - y;

}

console.log(subtract.length); // => 2, arity of the function (number of arguments)

/*

"function subtract(x, y) {

return x - y;

}"

*/

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Operators">Operators</h2></div>

The '+' operator is <a href="Operator_overloading" title="Operator overloading">overloaded</a>: it is used for string concatenation and arithmetic addition. This may cause problems when inadvertently mixing strings and numbers. As a unary operator, it can convert a numeric string to a number.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Concatenate 2 strings

console.log('He' + 'llo'); // displays Hello

// Add two numbers

console.log(2 + 6); // displays 8

// Adding a number and a string results in concatenation (from left to right)

console.log(2 + '2'); // displays 22

console.log('$' + 3 + 4); // displays $34, but $7 may have been expected

console.log('$' + (3 + 4)); // displays $7

console.log(3 + 4 + '7'); // displays 77, numbers stay numbers until a string is added

// Convert a string to a number using the unary plus

console.log(+'2' === 2); // displays true

console.log(+'Hello'); // displays NaN

</pre></div>

Similarly, the '*' operator is overloaded: it can convert a string into a number.

console.log(3*'7'); // 21

console.log('3'*'7'); // 21

console.log('hello'*'world'); // displays NaN

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Arithmetic">Arithmetic</h3></div>

JavaScript supports the following binary arithmetic operators:

<td>addition

</td></tr>

<tr>

<td>subtraction

</td></tr>

<tr>

<td>multiplication

</td></tr>

<tr>

<td>division (returns a floating-point value)

</td></tr>

<tr>

<td>modulo (returns the remainder)

</td></tr>

<tr>

<td>exponentiation

</td></tr></tbody></table>

JavaScript supports the following unary arithmetic operators:

<td>unary conversion of string to number

</td></tr>

<tr>

<td>unary negation (reverses the sign)

</td></tr>

<tr>

<td>increment (can be prefix or postfix)

</td></tr>

<tr>

<td>decrement (can be prefix or postfix)

</td></tr></tbody></table>

console.log(++x); // x becomes 2; displays 2

console.log(x++); // displays 2; x becomes 3

console.log(x); // x is 3; displays 3

console.log(x--); // displays 3; x becomes 2

console.log(--x); // x becomes 1; displays 1

</pre></div>

The modulo operator displays the remainder after division by the modulus. If negative numbers are involved, the returned value depends on the operand.

console.log(x%5); // displays 2

console.log(x%6); // displays 5

console.log(-x%5); // displays -2

console.log(-x%-5); // displays -2

console.log(x%-5); // displays 2

</pre></div>

To always return a non-negative number, users can re-add the modulus and apply the modulo operator again:

console.log((-x%5+5)%5); // displays 3

</pre></div>

Users could also do:

console.log(Math.abs(-x%5)); // also 3

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Assignment">Assignment</h3></div>

<td>assign

</td></tr>

<tr>

<td>add and assign

</td></tr>

<tr>

<td>subtract and assign

</td></tr>

<tr>

<td>multiply and assign

</td></tr>

<tr>

<td>divide and assign

</td></tr>

<tr>

<td>modulo and assign

</td></tr>

<tr>

<td>exponentiation and assign

</td></tr></tbody></table>

<a href="Assignment_(computer_science)" title="Assignment (computer science)">Assignment</a> of <a href="Primitive_type" class="mw-redirect" title="Primitive type">primitive types</a>

x += 1;

x *= 30;

x /= 6;

x -= 3;

x %= 7;

</pre></div>

Assignment of object types

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>/**

* To learn JavaScript objects...

*/

const object_1 = {a: 1}; // assign reference of newly created object to object_1

let object_2 = {a: 0};

let object_3 = object_2; // object_3 references the same object as object_2 does

object_3.a = 2;

message(); // displays 1 2 2

object_2 = object_1; // object_2 now references the same object as object_1

// object_3 still references what object_2 referenced before

message(); // displays 1 1 2

object_2.a = 7; // modifies object_1

message(); // displays 7 7 2

message(); // displays 7 7 5

object_3 = object_2;

object_3.a=4; // object_3 changes object_1 and object_2

message(); // displays 4 4 4

/**

* Prints the console.log message

*/

function message() {

console.log(object_1.a + " " + object_2.a + " " + object_3.a);

}

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Destructuring_assignment">Destructuring assignment</h4></div>

In Mozilla's JavaScript, since version 1.7, destructuring assignment allows the assignment of parts of data structures to several variables at once. The left hand side of an assignment is a pattern that resembles an arbitrarily nested object/array literal containing l-lvalues at its leaves that are to receive the substructures of the assigned value.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let a, b, c, d, e;

[a, b, c] = [3, 4, 5];

console.log(`${a},${b},${c}`); // displays: 3,4,5

e = {foo: 5, bar: 6, baz: ['Baz', 'Content']};

const arr = [];

({baz: [arr[0], arr[3]], foo: a, bar: b} = e);

console.log(`${a},${b},${arr}`); // displays: 5,6,Baz,,,Content

[a, b] = [b, a]; // swap contents of a and b

console.log(a + ',' + b); // displays: 6,5

[a, b, c] = [b, c, a];

</pre></div>

<div class="mw-heading mw-heading4"><h4 id="Spread/rest_operator">Spread/rest operator</h4></div>

The ECMAScript 2015 standard introduced the "<code>...</code>" array operator, for the related concepts of "spread syntax"<a href="#cite_note-16">[16]</a> and "rest parameters".<a href="#cite_note-17">[17]</a> Object spreading was added in ECMAScript 2018.

Spread syntax provides another way to destructure arrays and objects. For arrays, it indicates that the elements should be used as the parameters in a function call or the items in an array literal. For objects, it can be used for merging objects together or overriding properties.

In other words, "<code>...</code>" transforms "<code>[...foo]</code>" into "<code>[foo[0], foo[1], foo[2]]</code>", and "<code>this.bar(...foo);</code>" into "<code>this.bar(foo[0], foo[1], foo[2]);</code>", and "<code>{ ...bar }</code>" into <code>{ prop: bar.prop, prop2: bar.prop2 }</code>.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr mw-highlight-lines" dir="ltr"><pre>const a = [1, 2, 3, 4];

// It can be used multiple times in the same expression

const b = [...a, ...a]; // b = [1, 2, 3, 4, 1, 2, 3, 4];

// It can be combined with non-spread items.

const c = [5, 6, ...a, 7, 9]; // c = [5, 6, 1, 2, 3, 4, 7, 9];

// For comparison, doing this without the spread operator

// creates a nested array.

const d = [a, a]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]

// It works the same with function calls

function foo(arg1, arg2, arg3) {

console.log(`${arg1}:${arg2}:${arg3}`);

}

// Users can use it even if it passes more parameters than the function will use

foo(...a); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);

// Users can mix it with non-spread parameters

foo(5, ...a, 6); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);

// For comparison, doing this without the spread operator

// assigns the array to arg1, and nothing to the other parameters.

foo(a); // "1,2,3,4:undefined:undefined"

const bar = { a: 1, b: 2, c: 3 };

// This would copy the object

const copy = { ...bar }; // copy = { a: 1, b: 2, c: 3 };

// "b" would be overridden here

const override = { ...bar, b: 4 }; // override = { a: 1, c: 3, b: 4 }

</pre></div>

When <code>...</code> is used in a function declaration, it indicates a rest parameter. The rest parameter must be the final named parameter in the function's parameter list. It will be assigned an <code>Array</code> containing any arguments passed to the function in excess of the other named parameters. In other words, it gets "the rest" of the arguments passed to the function (hence the name).

console.log(c.length);

}

foo(1, 2, 3, 4, 5); // "3" → c = [3, 4, 5]

foo('a', 'b'); // "0" → c = []

</pre></div>

Rest parameters are similar to Javascript's <code>arguments</code> object, which is an array-like object that contains all of the parameters (named and unnamed) in the current function call. Unlike <code>arguments</code>, however, rest parameters are true <code>Array</code> objects, so methods such as <code>.slice()</code> and <code>.sort()</code> can be used on them directly.

<div class="mw-heading mw-heading3"><h3 id="Comparison">Comparison</h3></div>

<td>equal

</td></tr>

<tr>

<td>not equal

</td></tr>

<tr>

<td>greater than

</td></tr>

<tr>

<td>greater than or equal to

</td></tr>

<tr>

<td>less than

</td></tr>

<tr>

<td>less than or equal to

</td></tr>

<tr>

<td>identical (equal and of same type)

</td></tr>

<tr>

<td>not identical

</td></tr></tbody></table>

Variables referencing objects are equal or identical only if they reference the same object:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const obj1 = {a: 1};

const obj2 = {a: 1};

const obj3 = obj1;

console.log(obj1 == obj2); //false

console.log(obj3 == obj1); //true

console.log(obj3 === obj1); //true

</pre></div>

See also <a href="#String">String</a>.

<div class="mw-heading mw-heading3"><h3 id="Logical">Logical</h3></div>

JavaScript provides four logical operators:

<ul><li>unary <a href="Negation" title="Negation">negation</a> (<code>NOT = !a</code>)</li>

<li>binary <a href="Logical_disjunction" title="Logical disjunction">disjunction</a> (<code>OR = a || b</code>) and <a href="Logical_conjunction" title="Logical conjunction">conjunction</a> (<code>AND = a && b</code>)</li>

<li>ternary <a href="Conditional_(programming)" class="mw-redirect" title="Conditional (programming)">conditional</a> (<code>c ? t : f</code>)</li></ul>

In the context of a logical operation, any expression evaluates to true except the following:

<ul><li>Strings: <code>""</code>, <code>''</code>,</li>

<li>Numbers: <code>0</code>, <code>-0</code>, <code>NaN</code>,</li>

<li>Special: <code>null</code>, <code>undefined</code>,</li>

<li>Boolean: <code>false</code>.</li></ul>

The Boolean function can be used to explicitly convert to a primitive of type <code>Boolean</code>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Only empty strings return false

console.log(Boolean("") === false);

console.log(Boolean("false") === true);

console.log(Boolean("0") === true);

// Only zero and NaN return false

console.log(Boolean(NaN) === false);

console.log(Boolean(0) === false);

console.log(Boolean(-0) === false); // equivalent to -1*0

console.log(Boolean(-2) === true);

// All objects return true

console.log(Boolean(this) === true);

console.log(Boolean({}) === true);

console.log(Boolean([]) === true);

// These types return false

console.log(Boolean(null) === false);

console.log(Boolean(undefined) === false); // equivalent to Boolean()

</pre></div>

The NOT operator evaluates its operand as a Boolean and returns the negation. Using the operator twice in a row, as a <a href="Double_negative" title="Double negative">double negative</a>, explicitly converts an expression to a primitive of type Boolean:

console.log(Boolean(!0) === !!1);

console.log(!!1 === Boolean(1));

console.log(!!0 === Boolean(0));

console.log(Boolean(0) === !1);

console.log(!1 === Boolean(!1));

console.log(!"" === Boolean(!""));

console.log(Boolean(!"") === !!"s");

console.log(!!"s" === Boolean("s"));

console.log(!!"" === Boolean(""));

console.log(!"s" === Boolean(!"s"));

</pre></div>

The ternary operator can also be used for explicit conversion:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>console.log([] == false); console.log([] ? true : false); // “truthy”, but the comparison uses [].toString()

console.log([0] == false); console.log([0]? true : false); // [0].toString() == "0"

console.log("0" == false); console.log("0"? true : false); // "0" → 0 ... (0 == 0) ... 0 ← false

console.log([1] == true); console.log([1]? true : false); // [1].toString() == "1"

console.log("1" == true); console.log("1"? true : false); // "1" → 1 ... (1 == 1) ... 1 ← true

console.log([2] != true); console.log([2]? true : false); // [2].toString() == "2"

console.log("2" != true); console.log("2"? true : false); // "2" → 2 ... (2 != 1) ... 1 ← true

</pre></div>

Expressions that use features such as post–incrementation (<code>i++</code>) have an anticipated <a href="Side_effect_(computer_science)" title="Side effect (computer science)">side effect</a>. JavaScript provides <a href="Short-circuit_evaluation" title="Short-circuit evaluation">short-circuit evaluation</a> of expressions; the right operand is only executed if the left operand does not suffice to determine the value of the expression.

console.log(a && b); // When a is false, there is no reason to evaluate b.

console.log(c ? t : f); // When c is true, there is no reason to evaluate f.

</pre></div>

In early versions of JavaScript and <a href="JScript" title="JScript">JScript</a>, the binary logical operators returned a Boolean value (like most C-derived programming languages). However, all contemporary implementations return one of their operands instead:

console.log(a && b); // if a is false, return a, otherwise return b

</pre></div>

Programmers who are more familiar with the behavior in C might find this feature surprising, but it allows for a more concise expression of patterns like <a href="Null_coalescing_operator" title="Null coalescing operator">null coalescing</a>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const s = t || "(default)"; // assigns t, or the default value, if t is null, empty, etc.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Logical_assignment">Logical assignment</h3></div>

</td>

<td>Nullish assignment

</td></tr>

<tr>

</td>

<td>Logical Or assignment

</td></tr>

<tr>

</td>

<td>Logical And assignment

</td></tr></tbody></table>

<div class="mw-heading mw-heading3"><h3 id="Bitwise">Bitwise</h3></div>

JavaScript supports the following binary <a href="Bitwise_operation" title="Bitwise operation">bitwise operators</a>:

<td>AND

</td></tr>

<tr>

<td>OR

</td></tr>

<tr>

<td>XOR

</td></tr>

<tr>

<td>NOT

</td></tr>

<tr>

<td>shift left (zero fill at right)

</td></tr>

<tr>

<td>shift right (sign-propagating); copies of the leftmost bit (sign bit) are shifted in from the left

</td></tr>

<tr>

<td>shift right (zero fill at left). For positive numbers, <code>>></code> and <code>>>></code> yield the same result.

</td></tr></tbody></table>

Examples:

</pre></div>

JavaScript supports the following unary bitwise operator:

<td>NOT (inverts the bits)

</td></tr></tbody></table>

<div class="mw-heading mw-heading3"><h3 id="Bitwise_Assignment">Bitwise Assignment</h3></div>

JavaScript supports the following binary assignment operators:

<td>and

</td></tr>

<tr>

<td>or

</td></tr>

<tr>

<td>xor

</td></tr>

<tr>

<td>shift left (zero fill at right)

</td></tr>

<tr>

<td>shift right (sign-propagating); copies of the leftmost bit (sign bit) are shifted in from the left

</td></tr>

<tr>

<td>shift right (zero fill at left). For positive numbers, <code>>>=</code> and <code>>>>=</code> yield the same result.

</td></tr></tbody></table>

Examples:

x<<=3;

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="String_2">String</h3></div>

<td>assignment

</td></tr>

<tr>

<td>concatenation

</td></tr>

<tr>

<td>concatenate and assign

</td></tr></tbody></table>

Examples:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let str = "ab" + "cd"; // "abcd"

str += "e"; // "abcde"

const str2 = "2" + 2; // "22", not "4" or 4.

</pre></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .excerpt-hat .mw-editsection-like{font-style:normal}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable dablink excerpt-hat selfref">This section is an excerpt from <a href="Null_coalescing_operator#JavaScript" title="Null coalescing operator">Null coalescing operator § JavaScript</a>.[<a class="external text external" href="https://en.wikipedia.org/w/index.php?title=Null_coalescing_operator&action=edit">edit</a>]</div><div class="excerpt">

<a href="JavaScript" title="JavaScript">JavaScript</a>'s nearest operator is <code>??</code>, the "nullish coalescing operator", which was added to the standard in <a href="ECMAScript" title="ECMAScript">ECMAScript</a>'s 11th edition.<a href="#cite_note-18">[18]</a> In earlier versions, it could be used via a <a href="Babel_(compiler)" class="mw-redirect" title="Babel (compiler)">Babel</a> plugin, and in <a href="TypeScript" title="TypeScript">TypeScript</a>. It evaluates its left-hand operand and, if the result value is not "nullish" (<code>null</code> or <code>undefined</code>), takes that value as its result; otherwise, it evaluates the right-hand operand and takes the resulting value as its result.

In the following example, <code>a</code> will be assigned the value of <code>b</code> if the value of <code>b</code> is not <code>null</code> or <code>undefined</code>, otherwise it will be assigned 3.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const a = b ?? 3;

</pre></div>

Before the nullish coalescing operator, programmers would use the logical OR operator (<code>||</code>). But where <code>??</code> looks specifically for <code>null</code> or <code>undefined</code>, the <code>||</code> operator looks for any <a class="mw-selflink-fragment" href="#Boolean">falsy</a> value: <code>null</code>, <code>undefined</code>, <code>""</code>, <code>0</code>, <code>NaN</code>, and of course, <code>false</code>.

In the following example, <code>a</code> will be assigned the value of <code>b</code> if the value of <code>b</code> is <a class="mw-selflink-fragment" href="#Boolean">truthy</a>, otherwise it will be assigned 3.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const a = b || 3;

</pre></div></div></div>

<div class="mw-heading mw-heading2"><h2 id="Control_structures">Control structures</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Compound_statements">Compound statements</h3></div>

A pair of curly brackets <code>{ }</code> and an enclosed sequence of statements constitute a compound statement, which can be used wherever a statement can be used.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>if (expr) {

//statements;

} else {

//statements;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Conditional_(ternary)_operator">Conditional (ternary) operator</h3></div>

The conditional operator creates an expression that evaluates as one of two expressions depending on a condition. This is similar to the if statement that selects one of two statements to execute depending on a condition. I.e., the conditional operator is to expressions what if is to statements.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const result = condition ? expression : alternative;

</pre></div>

is the same as:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>if (condition) {

const result = expression;

} else {

}

</pre></div>

Unlike the if statement, the conditional operator cannot omit its "else-branch".

<div class="mw-heading mw-heading3"><h3 id="Switch_statement">Switch statement</h3></div>

The syntax of the JavaScript <a href="Control_flow#Choice" title="Control flow">switch statement</a> is as follows:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre> switch (expr) {

case SOMEVALUE:

// statements;

break;

case ANOTHERVALUE:

// statements for when ANOTHERVALUE || ORNAOTHERONE

// no break statement, falling through to the following case

case ORANOTHERONE:

// statements specific to ORANOTHERONE (i.e. !ANOTHERVALUE && ORANOTHER);

break; //The buck stops here.

case YETANOTHER:

// statements;

break;

default:

// statements;

break;

}

</pre></div>

<ul><li><code>break;</code> is optional; however, it is usually needed, since otherwise code execution will continue to the body of the next case block. This fall through behavior can be used when the same set of statements apply in several cases, effectively creating a <a href="Disjunction" class="mw-redirect" title="Disjunction">disjunction</a> between those cases.</li>

<li>Add a break statement to the end of the last case as a precautionary measure, in case additional cases are added later.</li>

<li>String literal values can also be used for the case values.</li>

<li>Expressions can be used instead of values.</li>

<li>The default case (optional) is executed when the expression does not match any other specified cases.</li>

<li>Braces are required.</li></ul>

The syntax of the JavaScript <a href="For_loop" title="For loop">for loop</a> is as follows:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre> for (initial; condition; loop statement) {

/*

statements will be executed every time

the for{} loop cycles, while the

condition is satisfied

*/

}

</pre></div>

or

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre> for (initial; condition; loop statement(iteration)) // one statement

</pre></div>

The syntax of the JavaScript <code><a href="Foreach_loop" title="Foreach loop">for ... in loop</a></code> is as follows:

// statements using some_object[property_name];

}

</pre></div>

<ul><li>Iterates through all enumerable properties of an object.</li>

<li>Iterates through all used indices of array including all user-defined properties of array object, if any. Thus it may be better to use a traditional for loop with a numeric index when iterating over arrays.</li>

<li>There are differences between the various Web browsers with regard to which properties will be reflected with the for...in loop statement. In theory, this is controlled by an internal state property defined by the ECMAscript standard called "DontEnum", but in practice, each browser returns a slightly different set of properties during introspection. It is useful to test for a given property using <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">if (some_object.hasOwnProperty(property_name)) { ... }</code>. Thus, adding a method to the array prototype with <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">Array.prototype.newMethod = function() {...}</code> may cause <code>for ... in</code> loops to loop over the method's name.</li></ul>

<div class="mw-heading mw-heading3"><h3 id="While_loop">While loop</h3></div>

The syntax of the JavaScript <a href="While_loop" title="While loop">while loop</a> is as follows:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>while (condition) {

statement1;

statement2;

statement3;

...

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Do_..._while_loop">Do ... while loop</h3></div>

The syntax of the JavaScript <code><a href="Do_while_loop" title="Do while loop">do ... while loop</a></code> is as follows:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>do {

statement1;

statement2;

statement3;

...

} while (condition);

</pre></div>

The with statement adds all of the given object's properties and methods into the following block's scope, letting them be referenced as if they were local variables.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>with (document) {

const a = getElementById('a');

const b = getElementById('b');

const c = getElementById('c');

};

</pre></div>

<ul><li>Note the absence of document. before each getElementById() invocation.</li></ul>

The semantics are similar to the with statement of <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a>.

Because the availability of with statements hinders program performance and is believed to reduce code clarity (since any given variable could actually be a property from an enclosing with), this statement is not allowed in strict mode.

<div class="mw-heading mw-heading3"><h3 id="Labels">Labels</h3></div>

JavaScript supports nested labels in most implementations. Loops or blocks can be labeled for the break statement, and loops for <code>continue</code>. Although <code><a href="Goto" title="Goto">goto</a></code> is a reserved word,<a href="#cite_note-19">[19]</a> <code>goto</code> is not implemented in JavaScript.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>loop1: for (let a = 0; a < 10; ++a) {

if (a === 4) break loop1; // Stops after the 4th attempt

console.log('a = ' + a);

loop2: for (let b = 0; b < 10; ++b) {

if (b === 3) continue loop2; // Number 3 is skipped

if (b === 6) continue loop1; // Continues the first loop, 'finished' is not shown

console.log('b = ' + b);

} //end of loop2

console.log('finished');

} //end of loop1

block1: {

console.log('Hello'); // Displays 'Hello'

break block1;

console.log('World'); // Will never get here

}

goto block1; // Parse error.

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Functions">Functions</h2></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Function_(computer_programming)" title="Function (computer programming)">Function (computer programming)</a></div>

A <a href="Function_(computer_programming)" title="Function (computer programming)">function</a> is a block with a (possibly empty) parameter list that is normally given a name. A function may use local variables. If a user exits the function without a return statement, the value undefined is returned.

<div class="mw-highlight mw-highlight-lang-javascript+genshitext mw-content-ltr" dir="ltr"><pre>function gcd(number1, number2) {

if (isNaN(number1*number2)) throw TypeError("Non-Numeric arguments not allowed.");

number1 = Math.round(number1);

number2 = Math.round(number2);

let difference = number1 - number2;

if (difference === 0) return number1;

return difference > 0 ? gcd(number2, difference) : gcd(number1, -difference);

}

console.log(gcd(60, 40)); // 20

//In the absence of parentheses following the identifier 'gcd' on the RHS of the assignment below,

//'gcd' returns a reference to the function itself without invoking it.

let mygcd = gcd; // mygcd and gcd reference the same function.

console.log(mygcd(60, 40)); // 20

</pre></div>

Functions are <a href="First_class_object" class="mw-redirect" title="First class object">first class objects</a> and may be assigned to other variables.

The number of arguments given when calling a function may not necessarily correspond to the number of arguments in the function definition; a named argument in the definition that does not have a matching argument in the call will have the value undefined (that can be implicitly cast to false). Within the function, the arguments may also be accessed through the arguments object; this provides access to all arguments using indices (e.g. <code class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" style="" dir="ltr">arguments[0], arguments[1], ... arguments[n]</code>), including those beyond the number of named arguments. (While the arguments list has a <code>.length</code> property, it is not an instance of Array; it does not have methods such as .slice(), .sort(), etc.)

if (!y) {

y = 7;

}

console.log(x + y + arguments.length);

};

add7(3); // 11

add7(3, 4); // 9

</pre></div>

Primitive values (number, boolean, string) are passed by value. For objects, it is the reference to the object that is passed.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const obj1 = {a : 1};

const obj2 = {b : 2};

function foo(p) {

p = obj2; // Ignores actual parameter

p.b = arguments[1];

}

foo(obj1, 3); // Does not affect obj1 at all. 3 is additional parameter

console.log(`${obj1.a} ${obj2.b}`); // writes 1 3

</pre></div>

Functions can be declared inside other functions, and access the outer function's local variables. Furthermore, they implement full <a href="Closure_(computer_science)" class="mw-redirect" title="Closure (computer science)">closures</a> by remembering the outer function's local variables even after the outer function has exited.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>let t = "Top";

let bar, baz;

function foo() {

let f = "foo var";

bar = function() { console.log(f) };

baz = function(x) { f = x; };

}

foo();

baz("baz arg");

bar(); // "baz arg" (not "foo var") even though foo() has exited.

console.log(t); // Top

</pre></div>

An anonymous function is simply a function without a name and can be written either using function or arrow notation. In these equivalent examples an anonymous function is passed to the map function and is applied to each of the elements of the array.<a href="#cite_note-20">[20]</a>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre> [1,2,3].map(function(x) { return x*2;); //returns [2,4,6]

[1,2,3].map((x) => { return x*2;}); //same result

</pre></div>

A generator function is signified placing an * after the keyword function and contains one or more yield statements. The effect is to return a value and pause execution at the current state. Declaring an generator function returns an iterator. Subsequent calls to iterator.next() resumes execution until the next yield. When the iterator returns without using a yield statement there are no more values and the done property of the iterator is set to true.<a href="#cite_note-21">[21]</a>

With the exception of <a href="IOS" title="IOS">iOS</a> devices from Apple, generators are not implemented for browsers on mobile devices. <a href="#cite_note-22">[22]</a>

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre> function* generator() {

yield "red";

yield "green";

yield "blue";

}

let iterator=generator();

let current;

while(current=iterator.next().value)

console.log(current); //displays red, green then blue

console.log(iterator.next().done) //displays true

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Async/await">Async/await</h3></div>

<div class="excerpt-block"><div role="note" class="hatnote navigation-not-searchable dablink excerpt-hat selfref">This section is an excerpt from <a href="Async/await#In_JavaScript" title="Async/await">Async/await § In JavaScript</a>.[<a class="external text external" href="https://en.wikipedia.org/w/index.php?title=Async/await&action=edit">edit</a>]</div><div class="excerpt">

The await operator in JavaScript can only be used from inside an async function or at the top level of a <a href="Modular_programming" title="Modular programming">module</a>. If the parameter is a <a href="Futures_and_promises" title="Futures and promises">promise</a>, execution of the async function will resume when the promise is resolved (unless the promise is rejected, in which case an error will be thrown that can be handled with normal JavaScript <a href="Exception_handling" title="Exception handling">exception handling</a>). If the parameter is not a promise, the parameter itself will be returned immediately.<a href="#cite_note-23">[23]</a>

Many libraries provide promise objects that can also be used with await, as long as they match the specification for native JavaScript promises. However, promises from the <a href="JQuery" title="JQuery">jQuery</a> library were not Promises/A+ compatible until jQuery 3.0.<a href="#cite_note-24">[24]</a>

Below is an example (modified from this<a href="#cite_note-Async/await_JavaScript-async-await-25">[25]</a> article):

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>async function createNewDoc() {

let response = await db.post({}); // post a new doc

return db.get(response.id); // find by id

}

async function main() {

try {

let doc = await createNewDoc();

console.log(doc);

} catch (err) {

console.log(err);

}

}

main();

</pre></div>

<a href="Node.js" title="Node.js">Node.js</a> version 8 includes a utility that enables using the standard library callback-based methods as promises.<a href="#cite_note-26">[26]</a></div></div>

<div class="mw-heading mw-heading2"><h2 id="Objects">Objects</h2></div>

For convenience, types are normally subdivided into primitives and objects. Objects are entities that have an identity (they are only equal to themselves) and that map property names to values ("slots" in <a href="Prototype-based_programming" title="Prototype-based programming">prototype-based programming</a> terminology). Objects may be thought of as <a href="Associative_arrays" class="mw-redirect" title="Associative arrays">associative arrays</a> or hashes, and are often implemented using these data structures. However, objects have additional features, such as a <a href="Prototype-based_programming" title="Prototype-based programming">prototype chain</a>, which ordinary associative arrays do not have.

JavaScript has several kinds of built-in objects, namely <code>Array</code>, <code>Boolean</code>, <code>Date</code>, <code>Function</code>, <code>Math</code>, <code>Number</code>, <code>Object</code>, <code>RegExp</code> and <code>String</code>. Other objects are "host objects", defined not by the language, but by the runtime environment. For example, in a browser, typical host objects belong to the DOM (window, form, links, etc.).

<div class="mw-heading mw-heading3"><h3 id="Creating_objects">Creating objects</h3></div>

Objects can be created using a constructor or an object literal. The constructor can use either a built-in Object function or a custom function. It is a convention that constructor functions are given a name that starts with a capital letter:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Constructor

const anObject = new Object();

// Object literal

const objectA = {};

const objectA2 = {}; // A != A2, {}s create new objects as copies.

const objectB = {index1: 'value 1', index2: 'value 2'};

// Custom constructor (see below)

</pre></div>

Object literals and array literals allow one to easily create flexible data structures:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>const myStructure = {

name: {

first: "Mel",

last: "Smith"

},

age: 33,

hobbies: ["chess", "jogging"]

};

</pre></div>

This is the basis for <a href="JSON" title="JSON">JSON</a>, which is a simple notation that uses JavaScript-like syntax for data exchange.

<div class="mw-heading mw-heading3"><h3 id="Methods">Methods</h3></div>

A <a href="Method_(computer_programming)" title="Method (computer programming)">method</a> is simply a function that has been assigned to a property name of an object. Unlike many object-oriented languages, there is no distinction between a function definition and a method definition in object-related JavaScript. Rather, the distinction occurs during function calling; a function can be called as a method.

When called as a method, the standard local variable this is just automatically set to the object instance to the left of the ".". (There are also call and apply methods that can set this explicitly—some packages such as <a href="JQuery" title="JQuery">jQuery</a> do unusual things with this.)

In the example below, Foo is being used as a constructor. There is nothing special about a constructor - it is just a plain function that initializes an object. When used with the new keyword, as is the norm, this is set to a newly created blank object.

Note that in the example below, Foo is simply assigning values to slots, some of which are functions. Thus it can assign different functions to different instances. There is no prototyping in this example.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>function px() { return this.prefix + "X"; }

function Foo(yz) {

this.prefix = "a-";

if (yz > 0) {

this.pyz = function() { return this.prefix + "Y"; };

} else {

this.pyz = function() { return this.prefix + "Z"; };

}

this.m1 = px;

return this;

}

const foo1 = new Foo(1);

const foo2 = new Foo(0);

foo2.prefix = "b-";

console.log("foo1/2 " + foo1.pyz() + foo2.pyz());

// foo1/2 a-Y b-Z

foo1.m3 = px; // Assigns the function itself, not its evaluated result, i.e. not px()

const baz = {"prefix": "c-"};

baz.m4 = px; // No need for a constructor to make an object.

console.log("m1/m3/m4 " + foo1.m1() + foo1.m3() + baz.m4());

// m1/m3/m4 a-X a-X c-X

foo1.m2(); // Throws an exception, because foo1.m2 does not exist.

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Constructors">Constructors</h3></div>

<a href="Constructor_function" class="mw-redirect" title="Constructor function">Constructor functions</a> simply assign values to slots of a newly created object. The values may be data or other functions.

Example: Manipulating an object:

this.attributeA = attributeA;

this.attributeB = attributeB;

}

MyObject.staticC = "blue"; // On MyObject Function, not object

console.log(MyObject.staticC); // blue

const object = new MyObject('red', 1000);

console.log(object.attributeA); // red

console.log(object.attributeB); // 1000

console.log(object.staticC); // undefined

object.attributeC = new Date(); // add a new property

delete object.attributeB; // remove a property of object

console.log(object.attributeB); // undefined

</pre></div>

The constructor itself is referenced in the object's prototype's constructor slot. So,

// Use of 'new' sets prototype slots (for example,

// x = new Foo() would set x's prototype to Foo.prototype,

// and Foo.prototype has a constructor slot pointing back to Foo).

const x = new Foo();

// The above is almost equivalent to

const y = {};

y.constructor = Foo;

y.constructor();

// Except

x.constructor == y.constructor; // true

x instanceof Foo; // true

y instanceof Foo; // false

// y's prototype is Object.prototype, not

// Foo.prototype, since it was initialized with

// {} instead of new Foo.

// Even though Foo is set to y's constructor slot,

// this is ignored by instanceof - only y's prototype's

// constructor slot is considered.

</pre></div>

Functions are objects themselves, which can be used to produce an effect similar to "static properties" (using C++/Java terminology) as shown below. (The function object also has a special <code>prototype</code> property, as discussed in the "Inheritance" section below.)

Object deletion is rarely used as the scripting engine will <a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collect</a> objects that are no longer being referenced.

<div class="mw-heading mw-heading3"><h3 id="Inheritance">Inheritance</h3></div>

JavaScript supports inheritance hierarchies through prototyping in the manner of <a href="Self_(programming_language)" title="Self (programming language)">Self</a>.

In the following example, the Derived class inherits from the Base class.

When d is created as Derived, the reference to the base instance of Base is copied to d.base.

Derive does not contain a value for aBaseFunction, so it is retrieved from aBaseFunction when aBaseFunction is accessed. This is made clear by changing the value of base.aBaseFunction, which is reflected in the value of d.aBaseFunction.

Some implementations allow the prototype to be accessed or set explicitly using the __proto__ slot as shown below.

this.anOverride = function() { console.log("Base::anOverride()"); };

this.aBaseFunction = function() { console.log("Base::aBaseFunction()"); };

}

function Derived() {

this.anOverride = function() { console.log("Derived::anOverride()"); };

}

const base = new Base();

Derived.prototype = base; // Must be before new Derived()

Derived.prototype.constructor = Derived; // Required to make `instanceof` work

const d = new Derived(); // Copies Derived.prototype to d instance's hidden prototype slot.

d instanceof Derived; // true

d instanceof Base; // true

base.aBaseFunction = function() { console.log("Base::aNEWBaseFunction()"); };

d.anOverride(); // Derived::anOverride()

d.aBaseFunction(); // Base::aNEWBaseFunction()

</pre></div>

The following shows clearly how references to prototypes are copied on instance creation, but that changes to a prototype can affect all instances that refer to it.

function m2() { return "Two"; }

function m3() { return "Three"; }

function Base() {}

Base.prototype.m = m2;

console.log("bar.m " + bar.m()); // bar.m Two

function Top() { this.m = m3; }

const t = new Top();

const foo = new Base();

Base.prototype = t;

// No effect on foo, the *reference* to t is copied.

console.log("foo.m " + foo.m()); // foo.m Two

const baz = new Base();

console.log("baz.m " + baz.m()); // baz.m Three

t.m = m1; // Does affect baz, and any other derived classes.

console.log("baz.m1 " + baz.m()); // baz.m1 One

</pre></div>

In practice many variations of these themes are used, and it can be both powerful and confusing.

<div class="mw-heading mw-heading2"><h2 id="Exception_handling">Exception handling</h2></div>

JavaScript includes a <code>try ... catch ... finally</code> <a href="Exception_handling" title="Exception handling">exception handling</a> statement to handle run-time errors.

The <code>try ... catch ... finally</code> statement catches <a href="Exception_handling" title="Exception handling">exceptions</a> resulting from an error or a throw statement. Its syntax is as follows:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>try {

// Statements in which exceptions might be thrown

} catch(errorValue) {

// Statements that execute in the event of an exception

} finally {

// Statements that execute afterward either way

}

</pre></div>

Initially, the statements within the try block execute. If an exception is thrown, the script's control flow immediately transfers to the statements in the catch block, with the exception available as the error argument. Otherwise the catch block is skipped. The catch block can throw(errorValue), if it does not want to handle a specific error.

In any case the statements in the finally block are always executed. This can be used to free resources, although memory is automatically garbage collected.

Either the catch or the finally clause may be omitted. The catch argument is required.

The Mozilla implementation allows for multiple catch statements, as an extension to the ECMAScript standard. They follow a syntax similar to that used in <a href="Java_(programming_language)" title="Java (programming language)">Java</a>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>try { statement; }

catch (e if e == "InvalidNameException") { statement; }

catch (e if e == "InvalidIdException") { statement; }

catch (e if e == "InvalidEmailException") { statement; }

catch (e) { statement; }

</pre></div>

In a browser, the onerror event is more commonly used to trap exceptions.

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>onerror = function (errorValue, url, lineNr) {...; return true;};

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Native_functions_and_methods">Native functions and methods</h2></div>

<div class="mw-heading mw-heading3"><h3 id="eval_(expression)">eval (expression)</h3></div>

Evaluates the first parameter as an expression, which can include assignment statements. Variables local to functions can be referenced by the expression. However, <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">eval</code> represents a major security risk, as it allows a bad actor to execute arbitrary code, so its use is discouraged.<a href="#cite_note-deve_eval-27">[27]</a>

<div class="mw-highlight mw-highlight-lang-nodejsrepl mw-content-ltr" dir="ltr"><pre>> (function foo() {

... var x = 7;

... console.log("val " + eval("x + 2"));

... })();

val 9

undefined

</pre></div>

<ul><li><a href="Comparison_of_JavaScript-based_source_code_editors" title="Comparison of JavaScript-based source code editors">Comparison of JavaScript-based source code editors</a></li>

<li><a href="JavaScript" title="JavaScript">JavaScript</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://hepunx.rl.ac.uk/~adye/jsspec11/intro.htm#1006028">"JavaScript 1.1 specification"</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20170226200426/http://hepunx.rl.ac.uk/~adye/jsspec11/intro.htm#1006028">Archived</a> from the original on 26 February 2017. Retrieved 19 April 2006.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20220210041253/http://speakingjs.com/es5/ch01.html">"Chapter 1. Basic JavaScript"</a>. speakingjs.com. Archived from <a rel="nofollow" class="external text" href="http://speakingjs.com/es5/ch01.html">the original</a> on 10 February 2022. Retrieved 22 September 2020.</cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite id="CITEREFFlanagan2006" class="citation book cs1">Flanagan, David (2006). <a rel="nofollow" class="external text" href="https://archive.org/details/javascript00libg_297">JavaScript: The definitive Guide</a>. "O'Reilly Media, Inc.". p. <a rel="nofollow" class="external text" href="https://archive.org/details/javascript00libg_297/page/n14">16</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-0-596-10199-2</bdi>. <q>Omitting semicolons is not a good programming practice; you should get into the habit of inserting them.</q></cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFFarias" class="citation web cs1">Farias, Bradley. <a rel="nofollow" class="external text" href="https://github.com/tc39/proposal-hashbang">"Hashbang Grammar"</a>. GitHub. Retrieved 13 July 2025.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/First_steps/Variables">"Storing the information you need — Variables - Learn web development | MDN"</a>. developer.mozilla.org. 9 May 2023. Retrieved 23 June 2023.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110629131728/https://developer.mozilla.org/en/JavaScript/Guide/Values%2C_Variables%2C_and_Literals%26revision%3D22#Variables">"Values, Variables, and Literals - MDC"</a>. Mozilla Developer Network. 16 September 2010. Archived from <a rel="nofollow" class="external text" href="https://developer.mozilla.org/en/JavaScript/Guide/Values,_Variables,_and_Literals&revision=22#Variables">the original</a> on 29 June 2011. Retrieved 1 February 2020.</cite>

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.w3schools.com/js/js_hoisting.asp">"JavaScript Hoisting"</a>. <a href="W3Schools" title="W3Schools">W3Schools</a>. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20220331225545/https://www.w3schools.com/js/js_hoisting.asp">Archived</a> from the original on 31 March 2022. Retrieved 17 December 2021. <q>In JavaScript, a variable can be declared after it has been used. In other words; a variable can be used before it has been declared.</q></cite>

</li>

<li id="cite_note-8"><a href="#cite_ref-8">^</a> "<a rel="nofollow" class="external text" href="http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html">JavaScript Scoping and Hoisting</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20210508121632/http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html">Archived</a> 8 May 2021 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>", <a rel="nofollow" class="external text" href="http://www.adequatelygood.com/about.html">Ben Cherry</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20210228091155/http://www.adequatelygood.com/about.html">Archived</a> 28 February 2021 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, <a rel="nofollow" class="external text" href="http://www.adequatelygood.com/">Adequately Good</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20220308081510/http://www.adequatelygood.com/">Archived</a> 8 March 2022 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, 8 February 2010

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> ECMA-262 5e edition clarified this behavior with the Declarative Environment Record and Object Environment Record. With this formalism, the global object is the Object Environment Record of the global Lexical Environment (the global scope).

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number">"Number - JavaScript"</a>. MDN Web Docs. Retrieved 13 July 2025.</cite>

</li>

<li id="cite_note-bigint-mdn-11">^ <a href="#cite_ref-bigint-mdn_11-0">a</a> <a href="#cite_ref-bigint-mdn_11-1">b</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt">"BigInt - Javascript"</a>. MDN Web Docs. Retrieved 13 July 2025.</cite>

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals">"Template literals"</a>. MDN Web Docs. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20220331204510/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals">Archived</a> from the original on 31 March 2022. Retrieved 4 November 2023.</cite>

</li>

<li id="cite_note-13"><a href="#cite_ref-13">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators">"Comparison Operators - MDC Doc Center"</a>. Mozilla. 5 August 2010. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20120504005400/https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators">Archived</a> from the original on 4 May 2012. Retrieved 5 March 2011.</cite>

</li>

<li id="cite_note-14"><a href="#cite_ref-14">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://javascript.crockford.com/style2.html">"The Elements of JavaScript Style"</a>. Douglas Crockford. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110317074944/http://javascript.crockford.com/style2.html">Archived</a> from the original on 17 March 2011. Retrieved 5 March 2011.</cite>

</li>

<li id="cite_note-15"><a href="#cite_ref-15">^</a> <cite id="CITEREFOrendorff" class="citation web cs1">Orendorff, Jason. <a rel="nofollow" class="external text" href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols"</a>. Mozilla Hacks. Retrieved 13 July 2025.</cite>

</li>

<li id="cite_note-16"><a href="#cite_ref-16">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax">"Spread syntax (...) - JavaScript | MDN"</a>. developer.mozilla.org. 25 September 2023.</cite>

</li>

<li id="cite_note-17"><a href="#cite_ref-17">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">"rest parameters"</a>. 9 September 2024. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20180530204951/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">Archived</a> from the original on 30 May 2018. Retrieved 29 September 2016.</cite>

</li>

<li id="cite_note-18"><a href="#cite_ref-18">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.ecma-international.org/ecma-262/11.0/index.html">"ECMAScript 2020 Language Specification"</a>. <a href="Ecma_International" title="Ecma International">Ecma International</a>. June 2020.</cite>

</li>

<li id="cite_note-19"><a href="#cite_ref-19">^</a> ECMA-262, Edition 3, 7.5.3 Future Reserved Words

</li>

<li id="cite_note-20"><a href="#cite_ref-20">^</a> <cite id="CITEREFYadav2024" class="citation web cs1">Yadav, Amitya (4 October 2024). <a rel="nofollow" class="external text" href="https://aditya003-ay.medium.com/named-function-vs-anonymous-function-impacts-94e2472ed7bb">"Named function vs Anonymous Function Impacts"</a>. medium.com. Retrieved 19 February 2025.</cite>

</li>

<li id="cite_note-21"><a href="#cite_ref-21">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*">"function*"</a>. mdm web docs. Retrieved 23 February 2025.</cite>

</li>

<li id="cite_note-22"><a href="#cite_ref-22">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://caniuse.com/?search=generator">"ES6 Generators"</a>. medium.com. Retrieved 23 February 2025.</cite>

</li>

<li id="cite_note-23"><a href="#cite_ref-23">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await">"await - JavaScript (MDN)"</a>. Retrieved 2 May 2017.</cite>

</li>

<li id="cite_note-24"><a href="#cite_ref-24">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://jquery.com/upgrade-guide/3.0/#breaking-change-and-feature-jquery-deferred-is-now-promises-a-compatible">"jQuery Core 3.0 Upgrade Guide"</a>. Retrieved 2 May 2017.</cite>

</li>

<li id="cite_note-Async/await_JavaScript-async-await-25"><a href="#cite_ref-Async/await_JavaScript-async-await_25-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://pouchdb.com/2015/03/05/taming-the-async-beast-with-es7.html">"Taming the asynchronous beast with ES7"</a>. Retrieved 12 November 2015.</cite>

</li>

<li id="cite_note-26"><a href="#cite_ref-26">^</a> <cite id="CITEREFFoundation2017" class="citation web cs1">Foundation, Node.js (30 May 2017). <a rel="nofollow" class="external text" href="https://nodejs.org/en/blog/release/v8.0.0/#improved-support-for-promises">"Node v8.0.0 (Current) - Node.js"</a>. Node.js.</cite>

</li>

<li id="cite_note-deve_eval-27"><a href="#cite_ref-deve_eval_27-0">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Never_use_eval!">"eval()"</a>. MDN Web Docs. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20220401220204/https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval#Never_use_eval!">Archived</a> from the original on 1 April 2022. Retrieved 29 January 2020.</cite>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>

<ul><li>Danny Goodman: JavaScript Bible, Wiley, John & Sons, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-7645-3342-8</bdi>.</li>

<li>David Flanagan, Paula Ferguson: JavaScript: The Definitive Guide, O'Reilly & Associates, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-596-10199-6</bdi>.</li>

<li>Thomas A. Powell, Fritz Schneider: JavaScript: The Complete Reference, McGraw-Hill Companies, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-07-219127-9</bdi>.</li>

<li>Axel Rauschmayer: Speaking JavaScript: An In-Depth Guide for Programmers, 460 pages, O'Reilly Media, 25 February 2014, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>978-1449365035</bdi>. (<a rel="nofollow" class="external text" href="http://speakingjs.com/">free online edition</a>)</li>

<li>Emily Vander Veer: JavaScript For Dummies, 4th Edition, Wiley, <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-7645-7659-3</bdi>.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .side-box{margin:4px 0;box-sizing:border-box;border:1px solid #aaa;font-size:88%;line-height:1.25em;background-color:var(--background-color-interactive-subtle,#f8f9fa);display:flow-root}.mw-parser-output .infobox .side-box{font-size:100%}.mw-parser-output .side-box-abovebelow,.mw-parser-output .side-box-text{padding:0.25em 0.9em}.mw-parser-output .side-box-image{padding:2px 0 2px 0.9em;text-align:center}.mw-parser-output .side-box-imageright{padding:2px 0.9em 2px 0;text-align:center}@media(min-width:500px){.mw-parser-output .side-box-flex{display:flex;align-items:center}.mw-parser-output .side-box-text{flex:1;min-width:0}}@media(min-width:720px){.mw-parser-output .side-box{width:238px}.mw-parser-output .side-box-right{clear:right;float:right;margin-left:1em}.mw-parser-output .side-box-left{margin-right:1em}}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1237033735">

/* start https://en.wikipedia.org/ */

@media print{body.ns-0 .mw-parser-output .sistersitebox{display:none!important}}@media screen{html.skin-theme-clientpref-night .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .sistersitebox img[src*="Wiktionary-logo-en-v2.svg"]{background-color:white}}

/* end https://en.wikipedia.org/ */

</style><div class="side-box side-box-right sistersitebox"><style data-mw-deduplicate="TemplateStyles:r1126788409">

/* start https://en.wikipedia.org/ */

.mw-parser-output .plainlist ol,.mw-parser-output .plainlist ul{line-height:inherit;list-style:none;margin:0;padding:0}.mw-parser-output .plainlist ol li,.mw-parser-output .plainlist ul li{margin-bottom:0}

/* end https://en.wikipedia.org/ */

</style>

<div class="side-box-text plainlist">Wikibooks has a book on the topic of: <a href="https://en.wikibooks.org/wiki/JavaScript" class="extiw external" title="wikibooks:JavaScript">JavaScript</a></div></div>

</div>

<ul><li><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en/docs/A_re-introduction_to_JavaScript">A re-introduction to JavaScript - Mozilla Developer Center</a></li>

<li><a rel="nofollow" class="external text" href="https://codetopology.com/category/scripts/javascript-tutorials/">JavaScript Loops</a></li>

<li>ECMAScript standard references: <a rel="nofollow" class="external text" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262</a></li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20120527095306/http://javalessons.com/cgi-bin/fun/java-tutorials-main.cgi?sub=javascript&code=script">Interactive JavaScript Lessons - example-based</a></li>

<li><a rel="nofollow" class="external text" href="http://javascript.about.com/">JavaScript on About.com: lessons and explanation</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20170225135310/http://javascript.about.com/">Archived</a> 25 February 2017 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a></li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20150110202627/http://wisentechnologies.com/it-courses/JavaScript-Training-in-Chennai.aspx">JavaScript Training</a></li>

<li>Mozilla Developer Center Core References for JavaScript versions <a rel="nofollow" class="external text" href="https://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference">1.5</a>, <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070210000908/http://research.nihonsoft.org/javascript/CoreReferenceJS14/index.html">1.4</a>, <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070210000504/http://research.nihonsoft.org/javascript/ClientReferenceJS13/index.html">1.3</a> and <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070210000545/http://research.nihonsoft.org/javascript/jsref/index.htm">1.2</a></li>

<li><a rel="nofollow" class="external text" href="https://developer.mozilla.org/en/docs/JavaScript">Mozilla JavaScript Language Documentation</a></li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="JavaScript497" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="JavaScript497" style="font-size:114%;margin:0 4em"><a href="JavaScript" title="JavaScript">JavaScript</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Static_program_analysis" title="Static program analysis">Code analysis</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="ESLint" title="ESLint">ESLint</a></li>

<li><a href="JSHint" title="JSHint">JSHint</a></li>

<li><a href="JSLint" title="JSLint">JSLint</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Subset" title="Subset">Supersets</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="ArkTS" title="ArkTS">ArkTS</a></li>

<li><a href="TypeScript" title="TypeScript">TypeScript</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Source-to-source_compiler" title="Source-to-source compiler">Transpilers</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="AtScript" title="AtScript">AtScript</a></li>

<li><a href="Babel_(transcompiler)" title="Babel (transcompiler)">Babel</a></li>

<li><a href="ClojureScript" class="mw-redirect" title="ClojureScript">ClojureScript</a></li>

<li><a href="CoffeeScript" title="CoffeeScript">CoffeeScript</a></li>

<li><a href="Emscripten" title="Emscripten">Emscripten</a></li>

<li><a href="Google_Closure_Compiler" class="mw-redirect" title="Google Closure Compiler">Google Closure Compiler</a></li>

<li><a href="Google_Web_Toolkit" title="Google Web Toolkit">Google Web Toolkit</a></li>

<li><a href="LiveScript_(programming_language)" title="LiveScript (programming language)">LiveScript</a></li>

<li><a href="Morfik" title="Morfik">Morfik</a></li>

<li><a href="PureScript" title="PureScript">PureScript</a></li>

<li><a href="Reason_(programming_language)" title="Reason (programming language)">Reason</a></li>

<li><a href="WebSharper" title="WebSharper">WebSharper</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Concepts</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="JavaScript_library" title="JavaScript library">JavaScript library</a></li>

<li><a href="JavaScript_stack" title="JavaScript stack">JavaScript stack</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Debugger" title="Debugger">Debuggers</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Chrome_(browser)" class="mw-redirect" title="Chrome (browser)">Chrome DevTools</a></li>

<li><a href="Firefox" title="Firefox">Firefox</a> Inspector</li>

<li><a href="Komodo_IDE" title="Komodo IDE">Komodo IDE</a></li>

<li><a href="Safari_(web_browser)" title="Safari (web browser)">Safari</a> Web Inspector</li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Documentation_generator" title="Documentation generator">Documentation generators</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="JSDoc" title="JSDoc">JSDoc</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Editors (<a href="Comparison_of_JavaScript-based_source_code_editors" title="Comparison of JavaScript-based source code editors">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Cloud9_IDE" title="Cloud9 IDE">Cloud9 IDE</a></li></ul></li>

<li><a href="CodeMirror" title="CodeMirror">CodeMirror</a>

<ul><li><a href="Brackets_(text_editor)" title="Brackets (text editor)">Brackets</a></li>

<li><a href="Light_Table_(software)" title="Light Table (software)">Light Table</a></li></ul></li>

<li><a href="PhpStorm" class="mw-redirect" title="PhpStorm">PhpStorm</a></li>

<li><a href="List_of_Eclipse_projects#Top-level_sub-projects" title="List of Eclipse projects">Orion</a></li>

<li><a href="Visual_Studio" title="Visual Studio">Visual Studio</a>

<ul><li><a href="Microsoft_Visual_Studio_Express" title="Microsoft Visual Studio Express">Visual Studio Express</a></li></ul></li>

<li><a href="Visual_Studio_Code" title="Visual Studio Code">Visual Studio Code</a></li>

<li><a href="Visual_Studio#Azure_DevOps_Services" title="Visual Studio">Visual Studio Team Services</a></li>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="JavaScript_engine" class="mw-redirect" title="JavaScript engine">Engines</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="List_of_ECMAScript_engines" class="mw-redirect" title="List of ECMAScript engines">List of ECMAScript engines</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Software_framework" title="Software framework">Frameworks</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Comparison_of_JavaScript-based_web_frameworks" title="Comparison of JavaScript-based web frameworks">Comparison of JavaScript frameworks</a></li>

<li><a href="List_of_JavaScript_libraries" title="List of JavaScript libraries">List of JavaScript libraries</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Related <a href="Technology" title="Technology">technologies</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="AssemblyScript" title="AssemblyScript">AssemblyScript</a></li>

<li><a href="Cascading_Style_Sheets" class="mw-redirect" title="Cascading Style Sheets">Cascading Style Sheets</a></li>

<li><a href="Document_Object_Model" title="Document Object Model">Document Object Model</a></li>

<li><a href="WebAssembly" title="WebAssembly">WebAssembly</a></li>

<li><a href="WebAuthn" title="WebAuthn">WebAuthn</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Package_manager" title="Package manager">Package managers</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Module bundlers</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Webpack" title="Webpack">Webpack</a></li>

<li><a href="Esbuild" title="Esbuild">esbuild</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Server-side_JavaScript" class="mw-redirect" title="Server-side JavaScript">Server-side</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Active_Server_Pages" title="Active Server Pages">Active Server Pages</a></li>

<li><a href="CommonJS" title="CommonJS">CommonJS</a></li>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Unit_testing" title="Unit testing">Unit testing</a> frameworks (<a href="List_of_unit_testing_frameworks#JavaScript" title="List of unit testing frameworks">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jasmine_(software)" title="Jasmine (software)">Jasmine</a></li>

<li><a href="Mocha_(JavaScript_framework)" title="Mocha (JavaScript framework)">Mocha</a></li>

<li><a href="QUnit" title="QUnit">QUnit</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">People</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Douglas_Crockford" title="Douglas Crockford">Douglas Crockford</a></li>

<li><a href="Brendan_Eich" title="Brendan Eich">Brendan Eich</a></li>

<li><a href="John_Resig" title="John Resig">John Resig</a></li>

<li><a href="Jesse_James_Garrett" title="Jesse James Garrett">Jesse James Garrett</a></li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-07-14" href="https://en.wikipedia.org/wiki/?title=JavaScript_syntax&oldid=1300481067">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>